"""笔记管理模块的数据模型

基于前端业务需求重构的简化数据模型。
完全匹配前端字段格式，删除不必要的复杂字段。
"""

import uuid
from django.db import models
from django.utils.translation import gettext_lazy as _
from django.contrib.auth import get_user_model
from django.core.validators import MinLengthValidator

User = get_user_model()


class Folder(models.Model):
    """文件夹模型
    
    完全匹配前端Folder接口的简化模型。
    """
    
    # 基础字段
    id = models.AutoField(
        primary_key=True,
        verbose_name=_('文件夹ID')
    )
    
    name = models.CharField(
        _('文件夹名称'),
        max_length=100,
        validators=[MinLengthValidator(1)],
        help_text=_('文件夹的名称')
    )
    
    count = models.PositiveIntegerField(
        _('笔记数量'),
        default=0,
        help_text=_('文件夹中的笔记数量')
    )
    
    # 前端特有字段
    isDefault = models.BooleanField(
        _('是否默认文件夹'),
        default=False,
        help_text=_('标记是否为默认文件夹（全部笔记、未分类笔记等）')
    )
    
    isShared = models.BooleanField(
        _('是否共享文件夹'),
        default=False,
        help_text=_('标记是否为共享文件夹')
    )
    
    # 层级关系
    parentId = models.ForeignKey(
        'self',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        related_name='children',
        verbose_name=_('父文件夹ID'),
        db_column='parent_id'
    )
    
    # 排序字段
    sortOrder = models.IntegerField(
        _('排序顺序'),
        default=0,
        help_text=_('文件夹的排序顺序，数字越小越靠前'),
        db_column='sort_order'
    )
    
    # 共享相关字段
    shareLink = models.URLField(
        _('共享链接'),
        max_length=500,
        blank=True,
        null=True,
        help_text=_('文件夹的共享链接')
    )
    
    sharePassword = models.CharField(
        _('共享密码'),
        max_length=50,
        blank=True,
        null=True,
        help_text=_('访问共享文件夹的密码')
    )
    
    # 同步相关字段
    syncStatus = models.CharField(
        _('同步状态'),
        max_length=20,
        choices=[
            ('local', _('本地')),
            ('pending', _('待同步')),
            ('synced', _('已同步')),
            ('syncing', _('同步中')),
            ('error', _('同步错误')),
        ],
        default='local',
        help_text=_('文件夹的同步状态')
    )
    
    serverId = models.CharField(
        _('服务器ID'),
        max_length=100,
        blank=True,
        null=True,
        help_text=_('服务器端的文件夹ID')
    )
    
    frontendId = models.CharField(
        _('前端ID'),
        max_length=100,
        blank=True,
        null=True,
        help_text=_('前端的文件夹ID，用于建立前后端关联')
    )
    
    # 用户关联
    created_by = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name='folders',
        verbose_name=_('创建者')
    )
    
    # 时间字段
    createdAt = models.DateTimeField(
        _('创建时间'),
        auto_now_add=True,
        db_column='created_at'
    )
    
    updatedAt = models.DateTimeField(
        _('更新时间'),
        auto_now=True,
        db_column='updated_at'
    )
    
    class Meta:
        verbose_name = _('文件夹')
        verbose_name_plural = _('文件夹')
        db_table = 'folder'
        ordering = ['isDefault', 'name']
        indexes = [
            models.Index(fields=['created_by', 'isDefault']),
            models.Index(fields=['parentId']),
            models.Index(fields=['isShared']),
        ]
    
    def __str__(self):
        """返回文件夹的字符串表示"""
        return self.name
    
    def save(self, *args, **kwargs):
        """保存文件夹时自动更新笔记数量"""
        super().save(*args, **kwargs)
        # 更新笔记数量
        self.update_count()
    
    def update_count(self):
        """更新文件夹中的笔记数量"""
        if self.name == '全部笔记':
            # 全部笔记：统计用户的所有笔记
            self.count = Note.objects.filter(author=self.created_by).count()
        else:
            # 其他文件夹：统计folderId匹配的笔记
            self.count = Note.objects.filter(folderId=self.id).count()
        
        # 避免递归调用save
        Folder.objects.filter(id=self.id).update(count=self.count)


class Note(models.Model):
    """笔记模型
    
    完全匹配前端Note接口的简化模型。
    """
    
    # 基础字段
    id = models.AutoField(
        primary_key=True,
        verbose_name=_('笔记ID')
    )
    
    title = models.CharField(
        _('笔记标题'),
        max_length=200,
        validators=[MinLengthValidator(1)],
        help_text=_('笔记的标题')
    )
    
    content = models.TextField(
        _('笔记内容'),
        help_text=_('笔记的内容')
    )
    
    # 文件夹关联
    folderId = models.IntegerField(
        _('文件夹ID'),
        null=True,
        blank=True,
        help_text=_('笔记所属的文件夹ID，为空表示属于全部文件夹')
    )
    
    # 共享相关字段
    isShared = models.BooleanField(
        _('是否共享'),
        default=False,
        help_text=_('标记笔记是否为共享状态')
    )
    
    shareLink = models.URLField(
        _('共享链接'),
        max_length=500,
        blank=True,
        null=True,
        help_text=_('笔记的共享链接')
    )
    
    sharePassword = models.CharField(
        _('共享密码'),
        max_length=50,
        blank=True,
        null=True,
        help_text=_('访问共享笔记的密码')
    )
    
    # 同步相关字段
    syncStatus = models.CharField(
        _('同步状态'),
        max_length=20,
        choices=[
            ('local', _('本地')),
            ('pending', _('待同步')),
            ('synced', _('已同步')),
            ('syncing', _('同步中')),
            ('error', _('同步错误')),
        ],
        default='local',
        help_text=_('笔记的同步状态')
    )
    
    serverId = models.CharField(
        _('服务器ID'),
        max_length=100,
        blank=True,
        null=True,
        help_text=_('服务器端的笔记ID')
    )
    
    frontendId = models.CharField(
        _('前端ID'),
        max_length=100,
        blank=True,
        null=True,
        help_text=_('前端的笔记ID，用于建立前后端关联')
    )
    
    # 标签（简化为字符串数组）
    tags = models.JSONField(
        _('标签'),
        default=list,
        blank=True,
        help_text=_('笔记的标签列表')
    )
    
    # 用户关联
    author = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name='notes',
        verbose_name=_('作者')
    )
    
    # 时间字段
    createdAt = models.CharField(
        _('创建时间'),
        max_length=50,
        default='2025年01月01日 00:00',
        help_text=_('创建时间（前端格式）'),
        db_column='created_at'
    )
    
    updatedAt = models.CharField(
        _('更新时间'),
        max_length=50,
        default='2025年01月01日 00:00',
        help_text=_('更新时间（前端格式）'),
        db_column='updated_at'
    )
    
    class Meta:
        verbose_name = _('笔记')
        verbose_name_plural = _('笔记')
        db_table = 'note'
        ordering = ['-id']  # 按ID倒序，最新的在前
        indexes = [
            models.Index(fields=['author', '-id']),
            models.Index(fields=['folderId', '-id']),
            models.Index(fields=['isShared']),
        ]
    
    def __str__(self):
        """返回笔记的字符串表示"""
        return self.title
    
    def save(self, *args, **kwargs):
        """保存笔记时自动更新相关文件夹的计数"""
        super().save(*args, **kwargs)
        # 更新相关文件夹的笔记数量
        self.update_folder_counts()
    
    def delete(self, *args, **kwargs):
        """删除笔记时自动更新相关文件夹的计数"""
        super().delete(*args, **kwargs)
        # 更新相关文件夹的笔记数量
        self.update_folder_counts()
    
    def update_folder_counts(self):
        """更新相关文件夹的笔记数量"""
        try:
            # 更新所属文件夹的计数
            folder = Folder.objects.filter(id=self.folderId, created_by=self.author).first()
            if folder:
                folder.update_count()
            
            # 更新"全部笔记"文件夹的计数
            all_notes_folder = Folder.objects.filter(
                name='全部笔记', 
                created_by=self.author,
                isDefault=True
            ).first()
            if all_notes_folder:
                all_notes_folder.update_count()
        except Exception:
            # 忽略更新错误，避免影响主要操作
            pass


class ShareLink(models.Model):
    """共享链接模型
    
    管理文件夹和笔记的共享链接。
    """
    
    # 基础字段
    shareId = models.CharField(
        _('共享ID'),
        max_length=100,
        unique=True,
        primary_key=True,
        help_text=_('唯一的共享标识符')
    )
    
    shareLink = models.URLField(
        _('共享链接'),
        max_length=500,
        help_text=_('完整的共享链接URL')
    )
    
    # 资源信息
    resourceType = models.CharField(
        _('资源类型'),
        max_length=20,
        choices=[
            ('folder', _('文件夹')),
            ('note', _('笔记')),
        ],
        help_text=_('共享的资源类型')
    )
    
    resourceId = models.IntegerField(
        _('资源ID'),
        help_text=_('被共享的资源ID')
    )
    
    # 访问控制
    password = models.CharField(
        _('访问密码'),
        max_length=50,
        blank=True,
        null=True,
        help_text=_('访问共享内容的密码')
    )
    
    expiresAt = models.DateTimeField(
        _('过期时间'),
        blank=True,
        null=True,
        help_text=_('共享链接的过期时间')
    )
    
    # 统计信息
    accessCount = models.PositiveIntegerField(
        _('访问次数'),
        default=0,
        help_text=_('共享链接被访问的次数')
    )
    
    # 用户关联
    created_by = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name='share_links',
        verbose_name=_('创建者')
    )
    
    # 时间字段
    createdAt = models.DateTimeField(
        _('创建时间'),
        auto_now_add=True,
        db_column='created_at'
    )
    
    class Meta:
        verbose_name = _('共享链接')
        verbose_name_plural = _('共享链接')
        db_table = 'share_link'
        ordering = ['-createdAt']
        indexes = [
            models.Index(fields=['created_by', '-createdAt']),
            models.Index(fields=['resourceType', 'resourceId']),
            models.Index(fields=['expiresAt']),
        ]
    
    def __str__(self):
        """返回共享链接的字符串表示"""
        return f'{self.resourceType}:{self.resourceId} - {self.shareId}'
    
    def is_expired(self):
        """检查共享链接是否已过期"""
        if not self.expiresAt:
            return False
        
        from django.utils import timezone
        return timezone.now() > self.expiresAt
    
    def increment_access_count(self):
        """增加访问次数"""
        self.accessCount += 1
        self.save(update_fields=['accessCount'])
